{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# User's Guide, Chapter 6: Streams (II): Hierarchies, Recursion, and Flattening"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "sphinx_links": {
     "any": true
    }
   },
   "source": [
    "We ended Chapter 4 (:ref:`Streams (I) <usersGuide_04_stream1>`.) with a :class:`~music21.stream.Stream` that was\n",
    "contained within another `Stream` object.  Let's recreate that class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from music21 import *\n",
    "\n",
    "note1 = note.Note(\"C4\")\n",
    "note1.duration.type = 'half'\n",
    "note2 = note.Note(\"F#4\")\n",
    "note3 = note.Note(\"B-2\")\n",
    "\n",
    "stream1 = stream.Stream()\n",
    "stream1.id = 'some notes'\n",
    "stream1.append(note1)\n",
    "stream1.append(note2)\n",
    "stream1.append(note3)\n",
    "\n",
    "biggerStream = stream.Stream()\n",
    "note2 = note.Note(\"D#5\")\n",
    "biggerStream.insert(0, note2)\n",
    "biggerStream.append(stream1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The only way to find out what was in the contained\n",
    "Stream that we demonstrated so far was the :meth:`~music21.base.Music21Object.show` method\n",
    "using the `('text')` argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0.0} <music21.note.Note D#>\n",
      "{1.0} <music21.stream.Stream some notes>\n",
      "    {0.0} <music21.note.Note C>\n",
      "    {2.0} <music21.note.Note F#>\n",
      "    {3.0} <music21.note.Note B->\n"
     ]
    }
   ],
   "source": [
    "biggerStream.show('text')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As Chapter 4 noted, there's a way to reach the inner notes such as `F#` via the `biggerStream[1][1]` format, but there's a better way to do that in music21, and for that we need to learn about subclasses of Streams and subclasses in general. (Skip this if you already know about such things from other programming experience)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classes and Subclasses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An object, such as a note or pitch, is basically a collection of information along with some actions that can be performed on that information.  A class is something that can make new objects of a certain type (sometimes this is called a factory).  We've seen classes such as the `note.Note` class, where the lowercase `note` is the \"module\" that the class `Note` lives in:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<module 'music21.note' from '/Users/cuthbert/music21/note.py'>\n"
     ]
    }
   ],
   "source": [
    "#_DOCS_SHOW note\n",
    "print(\"<module 'music21.note' from '/Users/cuthbert/music21/note.py'>\") #_DOCS_HIDE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'music21.note.Note'>\n"
     ]
    }
   ],
   "source": [
    "print(note.Note)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We create an object from a class by using the class name with `()` after it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<music21.note.Note C>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = note.Note()\n",
    "n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we've seen, we can sometimes put additional information into the `()`, such as a pitch name in the case of a `Note`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<music21.note.Note D#>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = note.Note('D#5')\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The variable `d` is now a `Note` object created from the `Note` class.  It's all a bit confusing, I know.  But we'll get to the point in a second.  If you want to find out more about what a `Note` object can do, the best thing is to read the `music21` instruction manual. :-) But for any class in Python, you can use the function `help(Class)` to find out what it can do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#_DOCS_SHOW help(note.Note)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "::\n",
    "\n",
    "    Help on class Note in module music21.note:\n",
    "    \n",
    "    class Note(NotRest)\n",
    "    |  One of the most important music21 classes, a Note\n",
    "    |  stores a single note (that is, not a rest or an unpitched element)\n",
    "    |  that can be represented by one or more notational units -- so\n",
    "    |  for instance a C quarter-note and a D# eighth-tied-to-32nd are both\n",
    "    |  a single Note object.\n",
    "    |  \n",
    "    |  *** ............ ***\n",
    "    |  \n",
    "    |  Method resolution order:\n",
    "    |      Note\n",
    "    |      NotRest\n",
    "    |      GeneralNote\n",
    "    |      music21.base.Music21Object\n",
    "    |      builtins.object\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice towards the very top there's the line `class Note(NotRest)`.  This says that the `Note` class is a \"subclass\" of a class called `NotRest` which contains all the information for note-like things such as `Note`, `Unpitched` percussion, and `Chord` that have stems, beams, etc. and are, well, not rests.  (Chris Ariza and I spent over an hour trying to come up with a better name for these things, but in the end we couldn't come up with anything better than `NotRest`, so it's stuck).\n",
    "\n",
    "What does it mean for `Note` to be a subclass of `NotRest`? It means that everything that `NotRest` can do, `Note` can do, and more. For instance, `NotRest` has a `.beams` property, so so does `Note`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<music21.beam.Beams> <music21.beam.Beams>\n"
     ]
    }
   ],
   "source": [
    "nr = note.NotRest()\n",
    "n = note.Note()\n",
    "print(nr.beams, n.beams)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But `Rest` is not a subclass of `NotRest` for obvious reasons. So a rest doesn't know anything about beams:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "tags": [
     "nbval-raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Rest' object has no attribute 'beams'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-9-4bd9333adfec>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnote\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mRest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbeams\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'Rest' object has no attribute 'beams'"
     ]
    }
   ],
   "source": [
    "r = note.Rest()\n",
    "r.beams"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But `Note` has properties that `NotRest` does not, such as `.pitch`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "tags": [
     "nbval-raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'NotRest' object has no attribute 'pitch'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-10-8983548bdf55>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpitch\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'NotRest' object has no attribute 'pitch'"
     ]
    }
   ],
   "source": [
    "print(nr.pitch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So classes and subclasses are a great way of making sure that things that are mostly similar have many of the same properties, but that they can have their own distinct information (`attributes`) and actions (`methods`).  Just FYI, here's how we create a subclass.  We can create a Class called `Japan` and then a subclass called `Okinawa` (my ancestral home) which has an additional attribute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Japan:\n",
    "    food = \"sushi\"\n",
    "    drink = \"sake\"\n",
    "    \n",
    "class Okinawa(Japan):\n",
    "    evenBetterFood = \"spam potstickers\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `(Japan)` in the class definition of `Okinawa` means that it inherits everything that Japan has and more:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sushi sake spam potstickers\n"
     ]
    }
   ],
   "source": [
    "o = Okinawa() \n",
    "print(o.food, o.drink, o.evenBetterFood)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But the joy of spam gyoza has not come to the mainland yet:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "tags": [
     "nbval-raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Japan' object has no attribute 'evenBetterFood'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-16-0ff50ac88c25>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mj\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mJapan\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mevenBetterFood\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'Japan' object has no attribute 'evenBetterFood'"
     ]
    }
   ],
   "source": [
    "j = Japan()\n",
    "print(j.evenBetterFood)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So this is how subclasses work in a nutshell.  The first subclasses we will be working with are the three fundamental subclasses of `Stream`: `Score`, `Part`, and `Measure`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Accessing Scores, Parts, Measures, and Notes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Streams provide a way to structure and position music21 objects both hierarchically and temporally. A Stream, or a Stream subclass such as :class:`~music21.stream.Measure`, can be placed within another Stream. \n",
    "\n",
    "A common arrangement of nested Streams is a \n",
    ":class:`~music21.stream.Score` Stream containing one or more \n",
    ":class:`~music21.stream.Part` Streams, each Part Stream in turn containing one \n",
    "or more :class:`~music21.stream.Measure` Streams. \n",
    "\n",
    "Such an arrangement of Stream objects is the common way musical scores are represented in music21. For example, importing a four-part chorale by J. S. Bach will provide a Score object with four Part Streams, each Part containing multiple Measure objects. Music21 comes with a :ref:`moduleCorpus` module that provides access to a large collection of scores, including all the Bach chorales. We can parse the score from the corpus with the :func:`~music21.corpus.parse` function, which we will discuss more in a bit.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "sBach = corpus.parse('bach/bwv57.8')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access and examine elements at each level of this Score by using standard Python syntax \n",
    "for lists within lists. Thus, we can see the length of each component: \n",
    "first the Score which has six elements:  a :class:`~music21.metadata.Metadata` object, a :class:`~music21.layout.StaffGroup` object, and four :class:`~music21.stream.Part` objects.\n",
    "Then we find the length of first Part at index three which indicates 14 objects (13 of them are measures).  \n",
    "Then within that part we find an object (a Measure) at index 1. All of these subprograms can\n",
    "be accessed from looking within the same score object `sBach`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(sBach)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(sBach[3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(sBach[3][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "sphinx_links": {
     "any": true
    }
   },
   "source": [
    "But how did we know that index [3] would be a Part and index [1][1] would\n",
    "be a measure?  As writers of the tutorial, we know this piece well enough\n",
    "to know that.  But as we noted above, more than just Measures might be \n",
    "stored in a Part object\n",
    "(such as :class:`~music21.instrument.Instrument` objects), \n",
    "and more than just Note and Rest objects might be stored in a Measure \n",
    "(such as :class:`~music21.meter.TimeSignature` \n",
    "and :class:`~music21.key.KeySignature` objects).  Therefore, it's much safer \n",
    "to filter Stream and Stream subclasses by \n",
    "the class we seek. \n",
    "\n",
    "To repeat the count and select specific classes, \n",
    "we can use the :meth:`~music21.stream.Stream.getElementsByClass` method that we discussed in :ref:`Chapter 4 <usersGuide_04_stream1>`.\n",
    "\n",
    "Notice how the counts deviate from the examples above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(sBach.getElementsByClass(stream.Part))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(sBach.getElementsByClass(stream.Part)[0].getElementsByClass(stream.Measure))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(sBach.getElementsByClass(stream.Part)[0].getElementsByClass(\n",
    "        stream.Measure)[1].getElementsByClass(note.Note))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "sphinx_links": {
     "any": true
    }
   },
   "source": [
    "Recall from :ref:`Chapter 4 <usersGuide_04_stream1>` that the :meth:`~music21.stream.Stream.getElementsByClass` method can also take a\n",
    "string representation of the last section of the class name. Thus we could've rewritten\n",
    "the first call above as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(sBach.getElementsByClass('Part'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This way of doing things is a bit faster to code, but a little less safe.  Suppose,\n",
    "for instance there were objects of type `stream.Measure` and `tape.Measure`; the latter\n",
    "way of writing the code would get both of them.  (But this ambiguity is rare enough\n",
    "that it's safe enough to use the strings in most code.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we introduced `.getElementsByClass()` we also introduced the convenience properties `.notes` and `.notesAndRests`. There is a convenience property for getting parts out as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(sBach.parts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You might think that there should be a convenience property `.measures` to get all the measures.  But the problem with that is that measure numbers would be quite different from index numbers. For instance,\n",
    "most pieces (that don't have pickup measures) begin with measure 1, not zero.  Sometimes there are measure\n",
    "discontinuities within a piece (e.g., some people number first and second endings with the same\n",
    "measure number). For that reason, gathering Measures is best accomplished not with `getElementsByClass(stream.Measure)`\n",
    "but instead with either \n",
    "the :meth:`~music21.stream.Stream.measures` method (returning a Stream of Parts or Measures) \n",
    "or the :meth:`~music21.stream.Stream.measure` method (returning a single Measure).  \n",
    "\n",
    "These are methods, not properties, so they use the `()` call.  Let's look at how we might use them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 155,
       "width": 748
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "alto = sBach.parts[1] # parts count from zero, so soprano is 0 and alto is 1\n",
    "excerpt = alto.measures(1, 4)\n",
    "excerpt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 155,
       "width": 748
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "measure2 = alto.measure(2) # measure not measure_s_\n",
    "measure2.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is great about `.measure()` and `.measures()` is that they can work on a whole score and not just a single part.  Sometimes computational musicologists and programmers call a collection of measures across parts a \"measureStack\".  So let's get the measure stack consisting of measure numbers 2 and 3 across all parts:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 385,
       "width": 748
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "measureStack = sBach.measures(2, 3)\n",
    "measureStack.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Recursion in Streams"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Streams` are hierarchical objects where the contained elements can themselves be Streams.  In order to get at each lower layer of the stream, a generator method on every stream called :meth:`~music21.stream.Stream.recurse` will visit every element in the stream, starting from the beginning, and if any of the subelements are also Streams, they will visit every element in that Stream.\n",
    "\n",
    "Let's create a simpler Stream to visualize what `.recurse()` does."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0.0} <music21.stream.Part part0>\n",
      "    {0.0} <music21.stream.Measure 1 offset=0.0>\n",
      "        {0.0} <music21.note.Note C>\n",
      "    {4.0} <music21.stream.Measure 2 offset=4.0>\n",
      "        {0.0} <music21.note.Note D>\n",
      "{0.0} <music21.stream.Part part1>\n",
      "    {0.0} <music21.stream.Measure 1 offset=0.0>\n",
      "        {0.0} <music21.note.Note E>\n",
      "    {4.0} <music21.stream.Measure 2 offset=4.0>\n",
      "        {0.0} <music21.note.Note F>\n"
     ]
    }
   ],
   "source": [
    "s = stream.Score(id='mainScore')\n",
    "p0 = stream.Part(id='part0')\n",
    "p1 = stream.Part(id='part1')\n",
    "\n",
    "m01 = stream.Measure(number=1)\n",
    "m01.append(note.Note('C', type=\"whole\"))\n",
    "m02 = stream.Measure(number=2)\n",
    "m02.append(note.Note('D', type=\"whole\"))\n",
    "p0.append([m01, m02])\n",
    "\n",
    "m11 = stream.Measure(number=1)\n",
    "m11.append(note.Note('E', type=\"whole\"))\n",
    "m12 = stream.Measure(number=2)\n",
    "m12.append(note.Note('F', type=\"whole\"))\n",
    "p1.append([m11, m12])\n",
    "\n",
    "s.insert(0, p0)\n",
    "s.insert(0, p1)\n",
    "s.show('text')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 121,
       "width": 226
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "s.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calling `.recurse()` on its own isn't very useful."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<music21.stream.iterator.RecursiveIterator for Score:mainScore @:0>"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recurseScore = s.recurse()\n",
    "recurseScore"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Where it becomes useful is in a `for` loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0 <music21.stream.Part part0> <music21.stream.Score mainScore>\n",
      "0.0 <music21.stream.Measure 1 offset=0.0> <music21.stream.Part part0>\n",
      "0.0 <music21.note.Note C> <music21.stream.Measure 1 offset=0.0>\n",
      "4.0 <music21.stream.Measure 2 offset=4.0> <music21.stream.Part part0>\n",
      "0.0 <music21.note.Note D> <music21.stream.Measure 2 offset=4.0>\n",
      "0.0 <music21.stream.Part part1> <music21.stream.Score mainScore>\n",
      "0.0 <music21.stream.Measure 1 offset=0.0> <music21.stream.Part part1>\n",
      "0.0 <music21.note.Note E> <music21.stream.Measure 1 offset=0.0>\n",
      "4.0 <music21.stream.Measure 2 offset=4.0> <music21.stream.Part part1>\n",
      "0.0 <music21.note.Note F> <music21.stream.Measure 2 offset=4.0>\n"
     ]
    }
   ],
   "source": [
    "for el in s.recurse():\n",
    "    print(el.offset, el, el.activeSite)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This example also introduces the concept of `.activeSite`, which for now can be thought of as the Stream that the element lives in; though we'll find that `Notes` and other elements can be in multiple Streams simultaneously, and this is just the one that they are most recently associated with.\n",
    "\n",
    "There are a lot of things that we can do with `.recurse()`, but let's just introduce one more thing for now.  Most \"filtering\" mechanisms, such as `.notes` can also be applied between the `()` of `recurse()` and the `:` at the end:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0 <music21.note.Note C> <music21.stream.Measure 1 offset=0.0>\n",
      "0.0 <music21.note.Note D> <music21.stream.Measure 2 offset=4.0>\n",
      "0.0 <music21.note.Note E> <music21.stream.Measure 1 offset=0.0>\n",
      "0.0 <music21.note.Note F> <music21.stream.Measure 2 offset=4.0>\n"
     ]
    }
   ],
   "source": [
    "for el in s.recurse().notes:\n",
    "    print(el.offset, el, el.activeSite)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    ".. note::\n",
    "\n",
    "   `.recurse()` is a generator in `music21`. Thus, it can only be used in `for` loops and other things that\n",
    "   iterate over each member of a list.  To treat the results of `.recurse()` as a list, you need to wrap it \n",
    "   with a `list()` call like so:\n",
    "   \n",
    "   >>> listRecurse = list(sBach.recurse())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In general, `.recurse()` is the best way to work through all the elements of a Stream, but there is another way that can be handy in some situations, and that is called `.flat`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Flattening a Stream"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While nested Streams offer expressive flexibility, it is often useful to be able to flatten all Stream and Stream subclasses into a single Stream containing only the elements that are not Stream subclasses. The  :attr:`~music21.stream.Stream.flat` property provides immediate access to such a flat representation of a Stream. For example, doing a similar count of components, such as that show above, we see that we cannot get to all of the Note objects of a complete Score until we flatten its Part and Measure objects by accessing the `flat` attribute. Note that for historical reasons, `.flat` is a property, so you do not use `()` around it.\n",
    "\n",
    "Let's look at what `.flat` does to the example score we created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0 <music21.note.Note C> <music21.stream.Score mainScore_flat>\n",
      "0.0 <music21.note.Note E> <music21.stream.Score mainScore_flat>\n",
      "4.0 <music21.note.Note D> <music21.stream.Score mainScore_flat>\n",
      "4.0 <music21.note.Note F> <music21.stream.Score mainScore_flat>\n"
     ]
    }
   ],
   "source": [
    "for el in s.flat:\n",
    "    print(el.offset, el, el.activeSite)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A new, temporary `Stream` with `id` of \"mainScore_flat\" has been created, and all of the `Note` objects are in there.  We didn't filter out non-Notes: `.flat` automatically removes all `Stream` objects and in this case there's nothing else but Notes in there.\n",
    "\n",
    "All the `Note` objects are now in the new temporary `mainScore_flat` object, and their offsets are no longer all `0.0`, but are instead measured from the start of the score being flattened.  So the whole notes in measure 2 are given offset `4.0`\n",
    "\n",
    "Compare what `.flat` lets you do when looking at a larger score.\n",
    "\n",
    "There are no Notes in the sBach stream..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(sBach.getElementsByClass(note.Note))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "...they are all inside Measures inside Parts inside the stream. (in a more complex score, they may be in Voices inside Measures inside Parts, etc.).  But they are all inside the flat version of the Stream:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "150"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(sBach.flat.getElementsByClass(note.Note))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Element offsets are always relative to the Stream that contains them. For example, a Measure, when placed in a Stream, might have an offset of 16. This offset describes the position of the Measure in the Stream. Components of this Measure, such as Notes, have offset values relative only to their container, the Measure. The first Note of this Measure, then, has an offset of 0. In the following example we find that the offset of measure eight (using the :meth:`~music21.base.Music21Object.getOffsetBySite` method) is 21; the offset of the second Note in this Measure (index 1), however, is 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21.0"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = sBach.parts[0].getElementsByClass('Measure')[7]\n",
    "m.getOffsetBySite(sBach.parts[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<music21.note.Note E->"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = sBach.parts[0].measure(8).notes[1]\n",
    "n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n.getOffsetBySite(m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Flattening a structure of nested Streams will set new, shifted offsets for each of the elements on the Stream, reflecting their appropriate position in the context of the Stream from which the `flat` property was accessed. For example, if a flat version of the first part of the Bach chorale is obtained, the note defined above has the appropriate offset of 22 (the Measure offset of 21 plus the Note offset within this Measure of 1). \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<music21.note.Note E->"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pFlat = sBach.parts[0].flat\n",
    "indexN = pFlat.index(n)\n",
    "pFlat[indexN]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "22.0"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pFlat[indexN].offset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "sphinx_links": {
     "any": true
    }
   },
   "source": [
    "As an aside, it is important to recognize that the offset of the Note has not been edited; instead, a Note, as all Music21Objects, can store multiple pairs of sites and offsets. Music21Objects retain an offset relative to all Stream or Stream subclasses they are contained within, even if just in passing.\n",
    "\n",
    "There's still a lot more to learn about `Streams`, but we can do that later. For now, let's move on to :ref:`Chapter 7: Chords <usersGuide_07_chords>`."
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
